home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / corelib / ncbifile.c < prev    next >
Text File  |  1996-07-05  |  31KB  |  1,245 lines
  1. /*   ncbifile.c
  2. * ===========================================================================
  3. *
  4. *                            PUBLIC DOMAIN NOTICE                          
  5. *               National Center for Biotechnology Information
  6. *                                                                          
  7. *  This software/database is a "United States Government Work" under the   
  8. *  terms of the United States Copyright Act.  It was written as part of    
  9. *  the author's official duties as a United States Government employee and 
  10. *  thus cannot be copyrighted.  This software/database is freely available 
  11. *  to the public for use. The National Library of Medicine and the U.S.    
  12. *  Government have not placed any restriction on its use or reproduction.  
  13. *                                                                          
  14. *  Although all reasonable efforts have been taken to ensure the accuracy  
  15. *  and reliability of the software and data, the NLM and the U.S.          
  16. *  Government do not and cannot warrant the performance or results that    
  17. *  may be obtained by using this software or data. The NLM and the U.S.    
  18. *  Government disclaim all warranties, express or implied, including       
  19. *  warranties of performance, merchantability or fitness for any particular
  20. *  purpose.                                                                
  21. *                                                                          
  22. *  Please cite the author in any work or product based on this material.   
  23. *
  24. * ===========================================================================
  25. *
  26. * File Name:  ncbifile.c
  27. *
  28. * Author:  Gish, Kans, Ostell, Schuler
  29. *
  30. * Version Creation Date:   3/4/91
  31. *
  32. * $Revision: 2.35 $
  33. *
  34. * File Description: 
  35. *     portable file routines
  36. *
  37. * Modifications:  
  38. * --------------------------------------------------------------------------
  39. * Date     Name        Description of modification
  40. * -------  ----------  -----------------------------------------------------
  41. * 04-15-93 Schuler     Changed _cdecl to LIBCALL
  42. * 12-20-93 Schuler     Converted ErrPost to ErrPostEx
  43. *
  44. * ==========================================================================
  45. */
  46.  
  47. #undef  THIS_MODULE
  48. #define THIS_MODULE g_corelib
  49. #undef  THIS_FILE
  50. #define THIS_FILE  _this_file
  51.  
  52. #include <ncbi.h>
  53. #include <ncbiwin.h>
  54.  
  55. #if (defined(OS_DOS) && defined(WIN_DUMB))
  56. #endif
  57.  
  58. #ifdef OS_MAC
  59. #include <Errors.h>
  60. #include <GestaltEqu.h>
  61. #include <Folders.h>
  62. #include <Strings.h>
  63. #endif
  64.  
  65. #ifdef OS_UNIX_SUN
  66. #include <sys/file.h>
  67. #include <sun/dkio.h>
  68. #include <sys/buf.h>
  69. #include <scsi/targets/srdef.h>
  70. #define DEFAULT_CDROM "/dev/sr0"
  71. #define DEFAULT_RAW_CDROM "/dev/rsr0"
  72. #endif
  73.  
  74. #ifdef PROC_MIPS
  75. #define DEFAULT_CDROM "/dev/scsi/sc0d4l0"
  76. #endif
  77.  
  78. #ifdef OS_UNIX
  79. #ifndef DEFAULT_CDROM
  80. #define DEFAULT_CDROM "/dev/cdrom"
  81. #endif
  82. #endif
  83.  
  84. #ifdef WIN_MSWIN
  85. static char * localbuf;
  86. static int filecount;
  87. #define LOCAL_BUF_SIZE 2*KBYTE
  88. #endif
  89.  
  90. #if (defined(OS_DOS) || defined (OS_NT))
  91. #ifdef WIN_DUMB
  92. #include <fcntl.h>         /* for setmode() */
  93. #include <io.h>
  94. #endif
  95. #ifdef COMP_MSC
  96. #include <direct.h>
  97. #ifndef mkdir
  98. #define mkdir _mkdir
  99. #endif
  100. #ifndef stat
  101. #define stat _stat
  102. #endif
  103. #endif
  104. #ifdef COMP_BOR
  105. #include <dir.h>
  106. #endif
  107.  
  108.  
  109. #if defined(COMP_CWI) || defined(OS_NT)
  110. #define WIN32 
  111. #include  <mapiwin.h>
  112.  
  113. #define  mkdir(name)   CreateDirectory( name, 0)
  114.  
  115. //#include <direct.h>
  116. //#include <stat.h>
  117. //#include <io.h>
  118. //int _CRTAPI1 stat(const char *, struct _stat *);
  119. //#ifndef stat
  120. //#define stat _stat
  121. //#endif
  122.  
  123. //int _CRTAPI1 mkdir(const char *);
  124. //#ifndef mkdir
  125. //#define mkdir _mkdir
  126. //#endif
  127.  
  128. #else
  129. #include <dir.h>
  130. #endif
  131. #endif
  132.  
  133. #ifdef OS_VMS
  134. #include <stat.h>   /* fstat function and buffer definition */
  135. #include <fab.h>    /* RFM (Record Format) definitions      */
  136. #ifndef DEFAULT_CDROM
  137. #define DEFAULT_CDROM "cdrom:"
  138. #endif
  139. #endif
  140.  
  141. extern char *g_corelib;
  142. static char * _this_file = __FILE__;
  143.  
  144.  
  145. /*****************************************************************************
  146. *
  147. *   Macintosh file utilities
  148. *
  149. *****************************************************************************/
  150.  
  151. #ifdef OS_MAC
  152. static short Nlm_MacGetVRefNum (Nlm_CharPtr pathname, OSErr *errptr)
  153.  
  154. {
  155.   OSErr           err;
  156.   FILE            *f;
  157.   Nlm_Char        filename [FILENAME_MAX];
  158.   Nlm_Char        path [256];
  159.   HParamBlockRec  pbh;
  160.   Nlm_CharPtr     ptr;
  161.  
  162.   memset (&pbh, 0, sizeof (HParamBlockRec));
  163.   Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  164.   ptr = Nlm_StringRChr (path, (int) DIRDELIMCHR);
  165.   if (ptr != NULL) {
  166.     ptr++;
  167.     Nlm_StringNCpy (filename, ptr, sizeof (filename) - 1);
  168.     *ptr = '\0';
  169. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  170.     c2pstr ((char *) path);
  171. #else
  172. #ifdef COMP_THINKC
  173.     CtoPstr ((char *) path);
  174. #endif
  175. #endif
  176.     pbh.volumeParam.ioNamePtr = (StringPtr) path;
  177.     pbh.volumeParam.ioVolIndex = -1;
  178.     err = PBHGetVInfo (&pbh, FALSE);
  179.     if (errptr != NULL) {
  180.       *errptr = err;
  181.     }
  182.     return pbh.volumeParam.ioVRefNum;
  183.   } else {
  184.     if (errptr != NULL) {
  185.       *errptr = noErr;
  186.     }
  187.     return 0;
  188.   }
  189. }
  190.  
  191. static long Nlm_MacGetDirID (Nlm_CharPtr pathname, short newVRefNum, OSErr *errptr)
  192.  
  193. {
  194.   OSErr           err;
  195.   FILE            *f;
  196.   Nlm_Char        path [256];
  197.   CInfoPBRec      pbc;
  198.   Nlm_CharPtr     ptr;
  199.  
  200.   memset (&pbc, 0, sizeof (CInfoPBRec));
  201.   Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  202.   ptr = Nlm_StringRChr (path, (int) DIRDELIMCHR);
  203.   if (ptr != NULL) {
  204.     ptr++;
  205.     Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  206.     *ptr = '\0';
  207. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  208.     c2pstr ((char *) path);
  209. #else
  210. #ifdef COMP_THINKC
  211.     CtoPstr ((char *) path);
  212. #endif
  213. #endif
  214.     pbc.dirInfo.ioNamePtr = (StringPtr) path;
  215.     pbc.dirInfo.ioVRefNum = newVRefNum;
  216.     err = PBGetCatInfo (&pbc, FALSE);
  217.     if (errptr != NULL) {
  218.       *errptr = err;
  219.     }
  220.     return pbc.dirInfo.ioDrDirID;
  221.   } else {
  222.     if (errptr != NULL) {
  223.       *errptr = noErr;
  224.     }
  225.     return 0;
  226.   }
  227. }
  228.  
  229. static OSErr Nlm_SetDefault (short newVRefNum, long newDirID, short *oldVRefNum, long *oldDirID)
  230.  
  231. {
  232.   OSErr  error;
  233.   long   procID;
  234.  
  235.   error = HGetVol (NULL, oldVRefNum, oldDirID);
  236.   if (error == noErr) {
  237.     error = HSetVol (NULL, newVRefNum, newDirID);
  238.   }
  239.   return (error);
  240. }
  241.  
  242. static OSErr Nlm_RestoreDefault (short oldVRefNum, long oldDirID)
  243.  
  244. {
  245.   OSErr  error;
  246.   short  defaultVRefNum;
  247.   long   defaultDirID;
  248.   long   defaultProcID;
  249.  
  250.   error = GetWDInfo (oldVRefNum, &defaultVRefNum, &defaultDirID, &defaultProcID);
  251.   if (error == noErr) {
  252.     if (defaultDirID != fsRtDirID) {
  253.       error = SetVol (NULL, oldVRefNum);
  254.     } else {
  255.       error = HSetVol (NULL, oldVRefNum, oldDirID);
  256.     }
  257.   }
  258.   return (error);
  259. }
  260. #endif
  261.  
  262. /*****************************************************************************
  263. *
  264. *   FileOpen(filename, mode)
  265. *     if (filename == "stdin" or "stdout" or "stderr"
  266. *           returns those predefined
  267. *           streams on non-windowing systems)
  268. *
  269. *****************************************************************************/
  270.  
  271. static Nlm_FileOpenHook _hookFile = NULL;
  272.  
  273. #ifdef COMP_MPW
  274. /*
  275. *  MPWOptimizationErrorBypass was called in order to avoid an apparent MPC C
  276. *  compiler optimization problem that resulted in the newDirID value sometimes
  277. *  appearing to be 0.  Placing any debugging statement (or this dummy function)
  278. *  after the statement that gets newDirID and before the statement that uses it
  279. *  originally appeared to fix the problem.  Upon further investigation, it turns
  280. *  out to be a problem with a UNIX to Mac file server product.  The problem did
  281. *  not occur when compiling under THINK C.
  282. */
  283.  
  284. static Nlm_Int2 Nlm_MPWOptimizationErrorBypass (short newVRefNum, long newDirID)
  285. {
  286. }
  287.  
  288. /*
  289. *  In MPW, if a temporary file is written first, without being created, it is
  290. *  created on the hard disk, rather than in the appropriate path.  This code
  291. *  creates the file in the desired location.
  292. */
  293.  
  294. static void Nlm_MPWCreateOutputFile (Nlm_CharPtr pathname, Nlm_CharPtr filename)
  295.  
  296. {
  297.   OSErr     err;
  298.   FILE      *f;
  299.   Nlm_Char  temp [256];
  300.  
  301.   f = fopen (filename, "r");
  302.   if (f == NULL) {
  303.     Nlm_StringNCpy (temp, pathname, sizeof (temp));
  304. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  305.   c2pstr ((char *) temp);
  306. #else
  307. #ifdef COMP_THINKC
  308.   CtoPstr ((char *) temp);
  309. #endif
  310. #endif
  311.     err = Create ((StringPtr) temp, 0, '    ', 'TEXT');
  312.   } else {
  313.     fclose (f);
  314.   }
  315. }
  316.  
  317. static FILE * LIBCALL  Nlm_MPWFileOpen (Nlm_CharPtr pathname, Nlm_CharPtr mode)
  318.  
  319. {
  320.   Nlm_Boolean  createfile;
  321.   OSErr        err;
  322.   FILE         *f;
  323.   long         newDirID;
  324.   short        newVRefNum;
  325.   long         oldDirID;
  326.   short        oldVRefNum;
  327.   Nlm_CharPtr  ptr;
  328.  
  329.   newVRefNum = Nlm_MacGetVRefNum (pathname, &err);
  330.   newDirID = Nlm_MacGetDirID (pathname, newVRefNum, &err);
  331.   ptr = Nlm_StringRChr (pathname, (int) DIRDELIMCHR);
  332.   createfile = (Nlm_Boolean) (strchr (mode, 'w') != NULL);
  333.   if (ptr != NULL) {
  334.     ptr++;
  335.     Nlm_MPWOptimizationErrorBypass (newVRefNum, newDirID);
  336.     err = Nlm_SetDefault (newVRefNum, newDirID, &oldVRefNum, &oldDirID);
  337.     if (createfile) {
  338.       Nlm_MPWCreateOutputFile (pathname, ptr);
  339.     }
  340.     f = fopen (ptr, mode);
  341.     err = Nlm_RestoreDefault (oldVRefNum, oldDirID);
  342.   } else {
  343.     if (createfile) {
  344.       Nlm_MPWCreateOutputFile (pathname, pathname);
  345.     }
  346.     f = fopen (pathname, mode);
  347.   }
  348.   return f;
  349. }
  350. #endif
  351.  
  352. FILE * LIBCALL  Nlm_FileOpen (const char *filename, const char *mode)
  353. {
  354.   FILE      *f;
  355. #ifdef OS_MAC
  356.   OSType    fCreator;
  357.   Nlm_Int2  fError;
  358.   FInfo     fInfo;
  359.   OSType    fType;
  360.   Nlm_Char  temp [256];
  361. #endif
  362.  
  363.   if (_hookFile != NULL) {
  364.     return _hookFile (filename, mode);
  365.   }
  366.   f = NULL;
  367. #ifdef WIN_DUMB
  368.   if (! StringCmp ("stdin", filename)) {
  369. #ifdef OS_DOS
  370.     if (strchr (mode, 'b') != NULL) {
  371.       setmode (fileno (stdin), O_BINARY);
  372.     }
  373. #endif
  374.     f = stdin;
  375.   } else if (! StringCmp ("stdout", filename)) {
  376. #ifdef OS_DOS
  377.     if (strchr (mode, 'b') != NULL) {
  378.       setmode (fileno (stdout), O_BINARY);
  379.     }
  380. #endif
  381.     f = stdout;
  382.   } else if (! StringCmp("stderr", filename)) {
  383.     f = stderr;
  384.   } else {
  385. #ifdef OS_VMS
  386.     f = fopen (filename, mode);
  387.     if (f) {
  388.       stat_t statbuf;
  389.       if ( fstat(fileno(f),&statbuf) == 0 ) {
  390.         if (statbuf.st_fab_rfm == FAB$C_UDF ) {
  391.           fclose(f);
  392.           f = fopen(filename,mode,"ctx=stm");
  393.         }
  394.       }
  395.     }
  396. #else
  397.     f = fopen (filename, mode);
  398. #endif
  399.   }
  400. #else
  401. #ifdef OS_MAC
  402.   Nlm_StringNCpy (temp, filename, sizeof (temp));
  403. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  404.     c2pstr ((char *) temp);
  405. #else
  406. #ifdef COMP_THINKC
  407.     CtoPstr ((char *) temp);
  408. #endif
  409. #endif
  410.   fError = GetFInfo ((StringPtr) temp, 0, &fInfo);
  411.   if (fError == 0) {
  412.     fCreator = fInfo.fdCreator;
  413.     fType = fInfo.fdType;
  414.   } else {
  415.     if (strchr (mode, 'b') != NULL) {
  416.       fType = '    ';
  417.     } else {
  418.       fType = 'TEXT';
  419.     }
  420.     fCreator = '    ';
  421.   }
  422. #endif
  423. #ifdef COMP_MPW
  424.   {
  425.     Nlm_Char  localmode [16];
  426.     Nlm_Char  path [PATH_MAX];
  427.     Nlm_StringNCpy (path, filename, sizeof (path) - 1);
  428.     Nlm_StringNCpy (localmode, mode, sizeof (localmode) - 1);
  429.     f = Nlm_MPWFileOpen (path, localmode);
  430.   }
  431. #else
  432. #ifdef OS_VMS
  433.  
  434.     f = fopen (filename, mode);
  435.     if (f) {
  436.       if ( fstat(fileno(f),&statbuf) == 0 ) {
  437.         if (statbuf.st_fab_rfm == FAB$C_UDF ) {
  438.           fclose(f);
  439.           f = fopen(filename,mode,"ctx=stm");
  440.         }
  441.       }
  442.     }
  443. #else
  444.   f = fopen (filename,mode);
  445. #endif
  446. #endif
  447. #ifdef OS_MAC
  448.   fError = GetFInfo ((StringPtr) temp, 0, &fInfo);
  449.   if (fError == 0) {
  450.     fInfo.fdCreator = fCreator;
  451.     fInfo.fdType = fType;
  452.     fError = SetFInfo ((StringPtr) temp, 0, &fInfo);
  453.   }
  454. #endif
  455. #endif
  456.  
  457.     if (f == NULL)
  458.         ErrPostEx(SEV_INFO,E_File,E_FOpen,"FileOpen(\"%s\",\"%s\") failed",filename,mode);
  459.         
  460.     return f;
  461. }
  462.  
  463. /*****************************************************************************
  464. *
  465. *   SetFileOpenHook(hook)
  466. *
  467. *****************************************************************************/
  468.  
  469. void LIBCALL Nlm_SetFileOpenHook (Nlm_FileOpenHook hook)
  470. {
  471.     _hookFile = hook;
  472. }
  473.  
  474. /*****************************************************************************
  475. *
  476. *   FileClose(fp)
  477. *
  478. *****************************************************************************/
  479.  
  480. void LIBCALL  Nlm_FileClose (FILE *stream)
  481. {
  482.     if (stream == NULL)
  483.         return;
  484.     
  485. #ifdef WIN_DUMB
  486.     if (stream==stdin || stream==stdout || stream==stderr)
  487.     {
  488. #ifdef OS_DOS
  489.         setmode(fileno(stream),O_TEXT);
  490. #endif
  491.     }
  492.     else 
  493.     {
  494.         fclose(stream);
  495.     }
  496. #else
  497.     fclose(stream);
  498. #endif
  499. }
  500.  
  501. /*****************************************************************************
  502. *
  503. *   FileRead(buf, size, fp)
  504. *
  505. *****************************************************************************/
  506. #ifdef WIN16
  507. #include <dos.h> /* dos.h defines the FP_SEG macro */
  508. #endif
  509.  
  510. Nlm_sizeT LIBCALL  Nlm_FileRead (void *ptr, Nlm_sizeT size, Nlm_sizeT n, FILE *stream)
  511. {
  512.     if ((n != 0) && ((Nlm_Int4)(SIZE_MAX / (Nlm_Int4) n) < (Nlm_Int4) size))
  513.         ErrPostEx(SEV_WARNING,E_Programmer,0,"FileRead: size > SIZE_MAX");
  514.     else if (ptr != NULL && stream != NULL)
  515.         return fread(ptr,size,n,stream);
  516.     return 0;
  517. }
  518.  
  519. /*****************************************************************************
  520. *
  521. *   FileWrite(buf, size, fp)
  522. *
  523. *****************************************************************************/
  524.  
  525. Nlm_sizeT LIBCALL  Nlm_FileWrite (const void *ptr, Nlm_sizeT size, Nlm_sizeT n, FILE *stream)
  526. {
  527.     if ((n != 0) && ((Nlm_Int4)(SIZE_MAX / (Nlm_Int4) n) < (Nlm_Int4) size))
  528.         ErrPostEx(SEV_WARNING,E_Programmer,0,"FileWrite:  size > SIZE_MAX");
  529.     else if (ptr != NULL && stream != NULL)
  530.     {
  531.         Nlm_sizeT cnt = fwrite(ptr,size,n,stream);
  532.         if (cnt != n)
  533.             ErrPostEx(SEV_FATAL,E_File,E_FWrite,"File write error");
  534.         return cnt;
  535.       }
  536.     return 0;
  537. }
  538.  
  539. /*****************************************************************************
  540. *
  541. *   FilePuts(ptr, fp)
  542. *
  543. *****************************************************************************/
  544. int LIBCALL  Nlm_FilePuts (const char *ptr, FILE *fp)
  545. {
  546.     int retval;
  547.  
  548.     if ((ptr == NULL) || (fp == NULL))
  549.         return EOF;
  550.     if ((retval = fputs(ptr,fp)) ==EOF)
  551.         ErrPostEx(SEV_FATAL,E_File,E_FWrite,"File write error");
  552.     return retval;
  553. }
  554.  
  555. /*****************************************************************************
  556. *
  557. *   FileGets()
  558. *
  559. *****************************************************************************/
  560. char * LIBCALL  Nlm_FileGets (Nlm_CharPtr ptr, Nlm_sizeT size, FILE *fp)
  561. {
  562.     if ((ptr == NULL) || (size <= 0) || (fp == NULL))
  563.         return NULL;
  564.     return fgets(ptr,size,fp);
  565. }
  566.  
  567.  
  568. /*****************************************************************************
  569. *
  570. *   FileBuildPath()
  571. *
  572. *****************************************************************************/
  573. Nlm_CharPtr LIBCALL  Nlm_FileBuildPath (Nlm_CharPtr root, Nlm_CharPtr sub_path, Nlm_CharPtr filename)
  574.  
  575. {
  576.     Nlm_CharPtr tmp;
  577.     Nlm_Boolean dir_start = FALSE;
  578. #ifdef OS_VMS
  579.   Nlm_Boolean had_root = FALSE;
  580. #endif
  581.  
  582.     if (root == NULL)              /* no place to put it */
  583.         return NULL;
  584.  
  585.     tmp = root;
  586.     if (*tmp != '\0')                /* if not empty */
  587.     {
  588. #ifndef OS_VMS
  589.         dir_start = TRUE;
  590. #else
  591.         had_root = TRUE;
  592. #endif
  593.         while (*tmp != '\0')
  594.         {
  595. #ifdef OS_VMS
  596.             if (*tmp == '[')
  597.                 dir_start = TRUE;
  598. #endif
  599.             tmp++;
  600.         }
  601.  
  602.         if ((*(tmp - 1) != DIRDELIMCHR) && (dir_start))
  603.         {
  604.             *tmp = DIRDELIMCHR;
  605.             tmp++; *tmp = '\0';
  606.         }
  607.     }
  608.  
  609.     if (sub_path != NULL)
  610.     {
  611. #ifdef OS_VMS
  612.         if (dir_start)
  613.         {
  614.             *(tmp-1) = '.';
  615.             if (*sub_path == '[')
  616.                 sub_path++;
  617.         }
  618.         else if ((had_root) && (*sub_path != '['))
  619.         {
  620.             *tmp = '[';
  621.             tmp++; *tmp = '\0';
  622.         }
  623. #else
  624.         if ((dir_start) && (*sub_path == DIRDELIMCHR))
  625.             sub_path++;
  626. #endif
  627.         tmp = StringMove(tmp, sub_path);
  628.         if (*(tmp-1) != DIRDELIMCHR)
  629.         {
  630.             *tmp = DIRDELIMCHR;
  631.             tmp++; *tmp = '\0';
  632.         }
  633.     }
  634.  
  635.     if (filename != NULL)
  636.         StringMove(tmp, filename);
  637.  
  638.     return root;
  639. }
  640.  
  641. /*****************************************************************************
  642. *
  643. *   FileNameFind()
  644. *
  645. *****************************************************************************/
  646. Nlm_CharPtr LIBCALL Nlm_FileNameFind (Nlm_CharPtr pathname)
  647.  
  648. {
  649.   Nlm_CharPtr  filename;
  650.   Nlm_Int2     len;
  651.  
  652.   if (pathname != NULL) {
  653.     len = Nlm_StringLen (pathname);
  654.     filename = &(pathname [len]);
  655.     while (len > 0 && pathname [len - 1] != DIRDELIMCHR) {
  656.       len--;
  657.       filename--;
  658.     }
  659.     return filename;
  660.   } else {
  661.     return NULL;
  662.   }
  663. }
  664.  
  665. /*****************************************************************************
  666. *
  667. *   FileLength()
  668. *
  669. *****************************************************************************/
  670. Nlm_Int4 LIBCALL Nlm_FileLength (Nlm_CharPtr fileName)
  671.  
  672. {
  673. #ifdef OS_MAC
  674.   ParamBlockRec  params;
  675.   OSErr          err;
  676.   Nlm_Char       path [256];
  677.   Nlm_Int4       rsult;
  678.  
  679.   rsult = 0;
  680.   if (fileName != NULL && fileName [0] != '\0') {
  681.     Nlm_StringNCpy (path, fileName, sizeof (path));
  682.     params.fileParam.ioNamePtr = (StringPtr) path;
  683.     params.fileParam.ioVRefNum = 0;
  684.     params.fileParam.ioFDirIndex = 0;
  685. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  686.     c2pstr ((char *) path);
  687. #elif defined( COMP_THINKC)
  688.     CtoPstr ((char *) path);
  689. #endif
  690.     err = PBGetFInfo (¶ms, FALSE);
  691.     if (err == noErr) {
  692.       rsult = params.fileParam.ioFlLgLen;
  693.     }
  694.   }
  695.   return rsult;
  696.   
  697. #elif defined(COMP_CWI) || defined(OS_NT)
  698.   Nlm_Int4     rsult;
  699.   rsult = 0;
  700.   if (fileName != NULL && fileName [0] != '\0') {
  701.     //FileSizeLow= GetFileSize(HANDLE hFile, &FileSizeHigh);
  702.     WIN32_FIND_DATA finfo;
  703.     HANDLE hFindFile;
  704.  
  705.       MemFill( &finfo, 0, sizeof(finfo));
  706.       finfo.dwFileAttributes= FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_NORMAL;
  707.     hFindFile= FindFirstFile( fileName, &finfo);
  708.     if (hFindFile) rsult= finfo.nFileSizeLow + finfo.nFileSizeHigh;
  709.     }
  710.   return rsult;    
  711.   
  712. #else
  713.   int          err;
  714.   Nlm_Char     local [256];
  715.   Nlm_Int4     rsult;
  716.   struct stat  sbuf;
  717.  
  718.   rsult = 0;
  719.   if (fileName != NULL && fileName [0] != '\0') {
  720.     Nlm_StringNCpy (local, fileName, sizeof (local));
  721.     err = stat (local, &sbuf);
  722.     if (err == 0) {
  723.       rsult = sbuf.st_size;
  724.     }
  725.   }
  726.   return rsult;
  727. #endif
  728. }
  729.  
  730. /*****************************************************************************
  731. *
  732. *   FileDelete()
  733. *
  734. *****************************************************************************/
  735. Nlm_Boolean LIBCALL Nlm_FileRemove (Nlm_CharPtr fileName)
  736.  
  737. {
  738.   Nlm_Char  local [256];
  739.  
  740.   if (fileName != NULL && fileName [0] != '\0') {
  741.     Nlm_StringNCpy (local, fileName, sizeof (local));
  742.     return (Nlm_Boolean) (remove (local) == 0);
  743.   } else {
  744.     return FALSE;
  745.   }
  746. }
  747.  
  748. /*****************************************************************************
  749. *
  750. *   FileRename()
  751. *
  752. *****************************************************************************/
  753. Nlm_Boolean LIBCALL Nlm_FileRename (Nlm_CharPtr oldFileName, Nlm_CharPtr newFileName)
  754.  
  755. {
  756.   Nlm_Char  localnew [256];
  757.   Nlm_Char  localold [256];
  758.  
  759.   if (oldFileName != NULL && oldFileName [0] != '\0'
  760.     && newFileName != NULL && newFileName [0] != '\0') {
  761.     Nlm_StringNCpy (localold, oldFileName, sizeof (localold));
  762.     Nlm_StringNCpy (localnew, newFileName, sizeof (localnew));
  763.     return (Nlm_Boolean) (rename (localold, localnew) == 0);
  764.   } else {
  765.     return FALSE;
  766.   }
  767. }
  768.  
  769. /*****************************************************************************
  770. *
  771. *   FileCreate()
  772. *
  773. *****************************************************************************/
  774. #ifdef WIN_MAC
  775. static OSType Nlm_GetOSType (Nlm_CharPtr str, OSType dfault)
  776.  
  777. {
  778.   OSType  rsult;
  779.  
  780.   rsult = dfault;
  781.   if (str != NULL && str [0] != '\0') {
  782.     rsult = *(OSType*) str;
  783.   }
  784.   return rsult;
  785. }
  786. #endif
  787.  
  788. void LIBCALL Nlm_FileCreate (Nlm_CharPtr fileName, Nlm_CharPtr type, Nlm_CharPtr creator)
  789.  
  790. {
  791.   FILE      *fp;
  792. #ifdef WIN_MAC
  793.   OSType    fCreator;
  794.   Nlm_Int2  fError;
  795.   OSType    fType;
  796.   Nlm_Char  temp [256];
  797. #endif
  798.  
  799.   if (fileName != NULL && fileName [0] != '\0') {
  800. #ifdef WIN_MAC
  801.     if (type != NULL || creator != NULL) {
  802.       fp = Nlm_FileOpen (fileName, "r");
  803.       if (fp == NULL) {
  804.         fType = Nlm_GetOSType (type, 'TEXT');
  805.         fCreator = Nlm_GetOSType (creator, '    ');
  806.         Nlm_StringNCpy (temp, fileName, sizeof (temp));
  807. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  808.     c2pstr ((char *) temp);
  809. #else
  810. #ifdef COMP_THINKC
  811.     CtoPstr ((char *) temp);
  812. #endif
  813. #endif
  814.         fError = Create ((StringPtr) temp, 0, fCreator, fType);
  815.       } else {
  816.         Nlm_FileClose (fp);
  817.       }
  818.     }
  819. #else
  820.     fp = Nlm_FileOpen (fileName, "w");
  821.     if (fp != NULL) {
  822.       Nlm_FileClose (fp);
  823.     }
  824. #endif
  825.   }
  826. }
  827.  
  828. /*****************************************************************************
  829. *
  830. *   CreateDir(pathname)
  831. *
  832. *****************************************************************************/
  833.  
  834. Nlm_Boolean LIBCALL  Nlm_CreateDir (Nlm_CharPtr pathname)
  835.  
  836. {
  837. #ifdef OS_MAC
  838.   long            dirID;
  839.   Nlm_Char        dirname [FILENAME_MAX];
  840.   OSErr           err;
  841.   Nlm_sizeT          len;
  842.   Nlm_Char        path [PATH_MAX];
  843.   HParamBlockRec  pbh;
  844.   Nlm_CharPtr     ptr;
  845.   short           vRefNum;
  846. #endif
  847. #if (defined(OS_DOS) || defined (OS_NT))
  848.   Nlm_sizeT          len;
  849.   Nlm_Char        path [PATH_MAX];
  850. #endif
  851. #ifdef OS_UNIX
  852.   Nlm_sizeT          len;
  853.   mode_t          oldmask;
  854.   Nlm_Char        path [PATH_MAX];
  855. #endif
  856.   Nlm_Boolean     rsult;
  857.  
  858.   rsult = FALSE;
  859.   if (pathname != NULL && pathname [0] != '\0') {
  860. #ifdef OS_MAC
  861.     Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  862.     len = Nlm_StringLen (path);
  863.     if (len > 0 && path [len - 1] == DIRDELIMCHR) {
  864.         path [len - 1] = '\0';
  865.     }
  866.     memset (&pbh, 0, sizeof (HParamBlockRec));
  867.     vRefNum = Nlm_MacGetVRefNum (path, &err);
  868.     if (err == noErr) {
  869.       dirID = Nlm_MacGetDirID (path, vRefNum, &err);
  870.       if (err == noErr) {
  871.         ptr = Nlm_StringRChr (path, (int) DIRDELIMCHR);
  872.         if (ptr != NULL) {
  873.           ptr++;
  874.           Nlm_StringNCpy (dirname, ptr, sizeof (dirname) - 1);
  875. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  876.     c2pstr ((char *) dirname);
  877. #else
  878. #ifdef COMP_THINKC
  879.     CtoPstr ((char *) dirname);
  880. #endif
  881. #endif
  882.           pbh.fileParam.ioNamePtr = (StringPtr) dirname;
  883.           pbh.fileParam.ioVRefNum = vRefNum;
  884.           pbh.fileParam.ioDirID = dirID;
  885.           err = PBDirCreate (&pbh, FALSE);
  886.           rsult = (Nlm_Boolean) (err == noErr || err == dupFNErr);
  887.         }
  888.       }
  889.     }
  890. #endif
  891. #if (defined(OS_DOS) || defined (OS_NT))
  892.     Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  893.     len = Nlm_StringLen (path);
  894.     if (len > 0 && path [len - 1] == DIRDELIMCHR) {
  895.         path [len - 1] = '\0';
  896.     }
  897.     rsult = (Nlm_Boolean) (mkdir ((char *) path) == 0);
  898.     if (errno == EACCES) { /* it's O.K. if it was already there */
  899.     rsult = TRUE;
  900.     }
  901. #endif
  902. #ifdef OS_UNIX
  903.     oldmask = umask (0000);
  904.     Nlm_StringNCpy (path, pathname, sizeof (path) - 1);
  905.     len = Nlm_StringLen (path);
  906.     if (len > 0 && path [len - 1] == DIRDELIMCHR) {
  907.         path [len - 1] = '\0';
  908.     }
  909.     rsult = (Nlm_Boolean) (mkdir ((char *) path, 0755) == 0);
  910.     if (errno == EEXIST) { /* it's O.K. if it was already there */
  911.     rsult = TRUE;
  912.     }
  913.     umask (oldmask);
  914. #endif
  915. #ifdef OS_VMS
  916.     rsult = (Nlm_Boolean) (mkdir ((char *) pathname, 0755) == 0);
  917. #endif
  918.   }
  919.   return rsult;
  920. }
  921.  
  922. /*****************************************************************************
  923. *
  924. *   TmpNam()
  925. *
  926. *****************************************************************************/
  927. Nlm_CharPtr LIBCALL Nlm_TmpNam (Nlm_CharPtr s)
  928.  
  929. {
  930. #ifdef TEMPNAM_AVAIL
  931.     char *filename;
  932.     static Nlm_Char save_filename[L_tmpnam+30];
  933.  
  934.     /* emulate tmpnam(), except get the benefits of tempnam()'s ability to */
  935.     /* place the files in another directory specified by the environment   */
  936.     /* variable TMPDIR                                                     */
  937.  
  938.     filename = tempnam("", "");
  939.  
  940.     if (s == NULL)
  941.     { /* return pointer to static string */
  942.         if (filename != NULL) {
  943.           strcpy ((char *) save_filename, (char *) filename);
  944.           free ((void *) filename);
  945.         } else {
  946.           save_filename [0] = '\0';
  947.         }
  948.         return save_filename;
  949.     } else {
  950.         if (filename != NULL) {
  951.           strcpy ((char *) save_filename, (char *) filename);
  952.           Nlm_StrCpy (s, save_filename);
  953.           free ((void *) filename);
  954.         } else {
  955.           *s = '\0';
  956.         }
  957.         return s;
  958.     }
  959. #else
  960. #ifdef OS_MAC
  961.     static Nlm_Char  directory [PATH_MAX];
  962.     OSErr        err;
  963.     long         gesResponse;
  964.     long         newDirID;
  965.     short        newVRefNum;
  966.     long         oldDirID;
  967.     short        oldVRefNum;
  968.     CInfoPBRec   params;
  969.     Nlm_Char     temp [PATH_MAX];
  970.     Nlm_CharPtr  tmp;
  971.     Nlm_Boolean  useTempFolder;
  972.     char * filename;
  973.  
  974.     useTempFolder = FALSE;
  975.     if (! Gestalt (gestaltFindFolderAttr, &gesResponse) &&
  976.         (gesResponse & (1 << gestaltFindFolderPresent))) {
  977.       err = FindFolder(kOnSystemDisk, kTemporaryFolderType,
  978.                        kCreateFolder, &newVRefNum, &newDirID);
  979.       if (err == noErr) {
  980.         useTempFolder = TRUE;
  981.         err = Nlm_SetDefault (newVRefNum, newDirID, &oldVRefNum, &oldDirID);
  982.       }
  983.     }
  984.     filename = tmpnam (NULL);
  985.     if (useTempFolder) {
  986.       err = Nlm_RestoreDefault (oldVRefNum, oldDirID);
  987.       temp [0] = '\0';
  988.       params.dirInfo.ioNamePtr = (StringPtr) directory;
  989.       params.dirInfo.ioDrParID = newDirID;
  990.       do {
  991.         params.dirInfo.ioVRefNum = newVRefNum;
  992.         params.dirInfo.ioFDirIndex = -1;
  993.         params.dirInfo.ioDrDirID = params.dirInfo.ioDrParID;
  994.         err = PBGetCatInfo (¶ms, FALSE);
  995. #if defined(COMP_MPW) || defined(COMP_CODEWAR)
  996.   p2cstr ((StringPtr) directory);
  997. #else
  998. #ifdef COMP_THINKC
  999.   PtoCstr ((StringPtr) directory);
  1000. #endif
  1001. #endif
  1002.         Nlm_StringCat (directory, DIRDELIMSTR);
  1003.         Nlm_StringCat (directory, temp);
  1004.         Nlm_StringCpy (temp, directory);
  1005.       } while (params.dirInfo.ioDrDirID != fsRtDirID);
  1006.       tmp = Nlm_StringMove (directory, temp);
  1007.       tmp = Nlm_StringMove (tmp, (Nlm_CharPtr) filename);
  1008.       if (s == NULL) {
  1009.           return (Nlm_CharPtr) directory;
  1010.       } else {
  1011.           s [0] = '\0';
  1012.           Nlm_StringCpy (s, directory);
  1013.           return s;
  1014.       }
  1015.     } else {
  1016.       if (s == NULL) {
  1017.           return (Nlm_CharPtr) filename;
  1018.       } else {
  1019.           s [0] = '\0';
  1020.           Nlm_StringCpy (s, filename);
  1021.           return s;
  1022.       }
  1023.     }
  1024. #else
  1025.     char * filename;
  1026.  
  1027.     filename = tmpnam (NULL);
  1028.     if (s == NULL) {
  1029.         return (Nlm_CharPtr) filename;
  1030.     } else {
  1031.         s [0] = '\0';
  1032.         Nlm_StringCpy (s, filename);
  1033.         return s;
  1034.     }
  1035. #endif
  1036. #endif
  1037. }
  1038.  
  1039. /*****************************************************************************
  1040. *
  1041. *   CD-ROM Ejection Routines
  1042. *
  1043. *****************************************************************************/
  1044.  
  1045. Nlm_Boolean LIBCALL  Nlm_EjectCd(Nlm_CharPtr sVolume, Nlm_CharPtr deviceName,
  1046.             Nlm_CharPtr rawDeviceName, 
  1047.             Nlm_CharPtr mountPoint,
  1048.             Nlm_CharPtr mountCmd)
  1049. {
  1050.     Nlm_Boolean retval = FALSE;
  1051. #ifdef OS_MAC
  1052.     OSErr err;
  1053.     Nlm_CharPtr prob_area = "Ejection";
  1054.     Nlm_Char    temp [64];
  1055.  
  1056.     
  1057.     Nlm_StringNCpy (temp, sVolume, sizeof (temp) - 1);
  1058.     Nlm_StringCat (temp, ":");
  1059.     if ((err = Eject((StringPtr) NULL, Nlm_MacGetVRefNum(temp, NULL))) == noErr)
  1060.     {
  1061.         if ((err = UnmountVol((StringPtr) NULL, Nlm_MacGetVRefNum(temp, NULL))) == noErr)
  1062.             return TRUE;
  1063.         
  1064.         /* We should still return TRUE if we Eject() successfully but failed to    */
  1065.         /* unmount the volume; however, we need to warn them, because a subsequent */
  1066.         /* GetFInfo() will result in a bus error, at least with System 7.0.        */
  1067.         retval = TRUE;
  1068.         prob_area = "Unmounting";
  1069.     }
  1070.  
  1071.     switch (err) {
  1072.     case bdNamErr:
  1073.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - bad volume name %s", prob_area, sVolume);
  1074.     break;
  1075.     case extFSErr:
  1076.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - external file system %s", prob_area, sVolume);
  1077.     break;
  1078.     case ioErr:
  1079.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - I/O error %s", prob_area, sVolume);
  1080.     break;
  1081.     case nsDrvErr:
  1082.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - No such drive %s", prob_area, sVolume);
  1083.     break;
  1084.     case nsvErr:
  1085.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - No such volume %s", prob_area, sVolume);
  1086.     break;
  1087.     case paramErr:
  1088.     ErrPostEx(SEV_ERROR,E_File,E_CdEject,"%s error - No default volume %s", prob_area, sVolume);
  1089.     break;
  1090.     }
  1091.     
  1092.     return retval;
  1093. #endif /* OS_MAC */
  1094.  
  1095. #ifdef OS_UNIX
  1096.     char cmd[100];
  1097. #endif
  1098. #ifdef OS_UNIX_SUN
  1099.     int fd;
  1100.  
  1101.     if (deviceName == NULL)
  1102.     {
  1103.         deviceName = DEFAULT_CDROM;
  1104.     }
  1105.  
  1106.     if (rawDeviceName == NULL)
  1107.     {
  1108.         rawDeviceName = DEFAULT_RAW_CDROM;
  1109.     }
  1110.  
  1111.     /* Open the CD-ROM character-based device */
  1112.     if ((fd = open(rawDeviceName, O_RDONLY, 0)) < 0)
  1113.     {
  1114.         ErrPostEx(SEV_ERROR,E_File,E_CdEject,"Ejection error - Unable to open device %s", rawDeviceName);
  1115.         return FALSE;
  1116.     }
  1117.  
  1118.     retval = ioctl(fd, CDROMEJECT, 0) >= 0;
  1119.     close (fd);
  1120.  
  1121.     if (! retval)
  1122.     {
  1123.         ErrPostEx(SEV_ERROR,E_File,E_CdEject,"Ejection error - Ioctl failure for %s", rawDeviceName);
  1124.         return FALSE;
  1125.     }
  1126. #endif /* OS_UNIX_SUN */
  1127.  
  1128. #ifdef OS_UNIX
  1129.     /* Now try to unmount device using (un)mount-script */
  1130.     if (mountCmd != NULL)
  1131.     {
  1132.         sprintf(cmd, "%s -u %s >/dev/null 2>/dev/null", mountCmd,
  1133.                 deviceName);
  1134.         retval = system(cmd) == 0;
  1135.     }
  1136.     else {
  1137.         if (deviceName != NULL)
  1138.         {
  1139.             retval = Message(MSG_OKC,
  1140.                             "Unmount device <%s> now; select OK when completed",
  1141.                             deviceName) != ANS_CANCEL;
  1142.         }
  1143.         else
  1144.         if (sVolume != NULL)
  1145.         {
  1146.             retval = Message(MSG_OKC,
  1147.                             "Unmount volume <%s> now; select OK when completed",
  1148.                             sVolume) != ANS_CANCEL;
  1149.         }
  1150.         else
  1151.         {
  1152.             retval = Message(MSG_OKC,
  1153.                             "Unmount CD-ROM now; select OK when completed") !=
  1154.                             ANS_CANCEL;
  1155.         }
  1156.     }
  1157. #endif /* OS_UNIX */
  1158.  
  1159. #ifdef OS_VMS
  1160.     char  cmd[100];
  1161.     char  tmp[100];
  1162.     char* cPtr;
  1163.  
  1164.  
  1165.     if ( mountPoint == NULL || *mountPoint == '\0' ) 
  1166.         strcpy(tmp,DEFAULT_CDROM); 
  1167.     else {
  1168.         strcpy(tmp,mountPoint);
  1169.         if ( cPtr = strchr(tmp,':') ) *(cPtr+1) = '\0';
  1170.     }
  1171.     /* 
  1172.     ** Try to mount device using mount-script 
  1173.     */
  1174.  
  1175.     sprintf(cmd, "CD_DISMOUNT/UNLOAD %s",tmp);
  1176.     retval = (system(cmd) == 0);
  1177.  
  1178.      Message(MSG_OK,
  1179.         "Press the eject button on <%s>.",tmp);
  1180.  
  1181. #endif
  1182.     
  1183.     return retval;
  1184. }
  1185.  
  1186. Nlm_Boolean LIBCALL  Nlm_MountCd(Nlm_CharPtr sVolume, Nlm_CharPtr deviceName,
  1187.             Nlm_CharPtr mountPoint, Nlm_CharPtr mountCmd)
  1188. {
  1189.     Nlm_Boolean retval = FALSE;
  1190.  
  1191. #ifdef OS_UNIX
  1192.     char cmd[100];
  1193.  
  1194.     if (deviceName == NULL)
  1195.     {
  1196.         deviceName = DEFAULT_CDROM;
  1197.     }
  1198.  
  1199.     /* Try to mount device using mount-script */
  1200.     if (mountCmd != NULL)
  1201.     {
  1202.         sprintf(cmd, "%s -m %s %s >/dev/null 2>/dev/null", mountCmd, deviceName,
  1203.                 mountPoint != NULL ? mountPoint : "");
  1204.         retval = system(cmd) == 0;
  1205.     }
  1206.     else {
  1207.         if (deviceName != NULL)
  1208.         {
  1209.         }
  1210.         else
  1211.         {
  1212.             retval = Message(MSG_OKC,
  1213.                             "Mount CD-ROM now; select OK when completed") !=
  1214.                             ANS_CANCEL;
  1215.         }
  1216.     }
  1217. #endif
  1218.  
  1219. #ifdef OS_VMS
  1220.     char  cmd[100];
  1221.     char  tmp[100];
  1222.     char* cPtr;
  1223.  
  1224.  
  1225.     if ( mountPoint == NULL || *mountPoint == '\0' ) 
  1226.         strcpy(tmp,DEFAULT_CDROM); 
  1227.     else {
  1228.         strcpy(tmp,mountPoint);
  1229.         if ( cPtr = strchr(tmp,':') ) *(cPtr+1) = '\0';
  1230.     }
  1231.  
  1232.  
  1233.     /* Try to mount device using mount-script */
  1234.  
  1235.     sprintf(cmd, "CD_MOUNT/MEDIA=CDROM/OVERRIDE=IDENTIFICATION/NOASSIST %s",
  1236.           tmp);
  1237.  
  1238.     retval = (system(cmd) == 0);
  1239.  
  1240. #endif
  1241.  
  1242.     return retval;
  1243. }
  1244.  
  1245.